QuickTime - The Beta Release/QuickTime - The Beta Release.iso/Programming Stuff/Interfaces/Movies Interfaces/MoviesFormat.h

C/C++ Source or Header | 1991-09-06 | 12.2 KB | 504 lines | [TEXT/MPS ]

/************************************************************

Created: Wednesday, August 28, 1991 at 1:56 AM
 MoviesFormat.h
 C Interface to the Macintosh Libraries


  Copyright Apple Computer, Inc. 1991
  All rights reserved

************************************************************/


#ifndef __MOVIESFORMAT__
#define __MOVIESFORMAT__

#ifndef __MOVIES__
#include <Movies.h>
#endif

#define kMovieVersion    (-1)                /* version number of the format here described */

struct MoviesUserData {
    long        size;                        /* size of this user data */
    long        type;                        /* type of user data */
    char         data[1];                    /* the user data */
};
typedef struct MoviesUserData MoviesUserData;

struct UserDataAtom {
    long             size;
    long            type;                    /* = 'udat' */
    MoviesUserData    userData[1];
};
typedef struct UserDataAtom UserDataAtom;

/*
struct SampleDescription {
    long        size;
    long        type;
    long        resvd1;
    short        resvdA;
    short        dataRefBlobId;
    };
typedef struct SampleDescription SampleDescription;
*/

struct SampleDescriptionAtom {
    long        size;
    long        type;                            /* = 'stsd' */
    long        flags;                            /* 1 byte of version / 3 bytes of flags */
    long        numEntries;
    SampleDescription    sampleDescTable[1];
};
typedef struct SampleDescriptionAtom SampleDescriptionAtom;

struct TimeToSampleNum {
    long        sampleCount;
    TimeValue    sampleDuration;
};
typedef struct TimeToSampleNum TimeToSampleNum;

struct TimeToSampleNumAtom {
    long        size;
    long        type;                            /* = 'stgs' */
    long        flags;                            /* 1 byte of version / 3 bytes of flags */
    long        numEntries;
    TimeToSampleNum    timeToSampleNumTable[1];
};
typedef struct TimeToSampleNumAtom TimeToSampleNumAtom;

struct SyncSampleAtom{
    long        size;
    long        type;                                /* = 'stss' */
    long        flags;                                /* 1 byte of version / 3 bytes of flags */
    long        numEntries;
    long        syncSampleTable[1];
};
typedef struct SyncSampleAtom SyncSampleAtom;

struct SampleToChunk {
    long        firstSample;
    long        firstChunk;
    long        samplesPerChunk;
    long        sampleDescriptionID;
};
typedef struct SampleToChunk SampleToChunk;

struct SampleToChunkAlternate1 {                /* same as SampleToChunk, but redundant first sample is removed */
    long        firstChunk;
    long        samplesPerChunk;
    long        sampleDescriptionID;
};
typedef struct SampleToChunkAlternate1 SampleToChunkAlternate1;

enum {sampleToChunkAlternate1 = 1<<0};
typedef unsigned char SampleToChunkFlags;

struct SampleToChunkAtom {
    long        size;
    long        type;                                /* = 'stsc' */
    long        flags;                                /* 1 byte of version / 3 bytes of flags */
    long        numEntries;
    SampleToChunk    sampleToChunkTable[1];
};
typedef struct SampleToChunkAtom SampleToChunkAtom;

struct ChunkOffsetAtom {
    long        size;
    long        type;                                /* = 'stco' */
    long        flags;                                /* 1 byte of version / 3 bytes of flags */
    long        numEntries;
    long        chunkOffsetTable[1];
};
typedef struct ChunkOffsetAtom ChunkOffsetAtom;

struct SampleSizeAtom {
    long        size;
    long        type;                                /* = 'stsz' */
    long        flags;                                /* 1 byte of version / 3 bytes of flags */
    long        sampleSize;
    long        numEntries;
    long        sampleSizeTable[1];
};
typedef struct SampleSizeAtom SampleSizeAtom;

struct SampleTableAtom {
    long        size;
    long        type;            /* = 'stbl' */

    SampleDescriptionAtom    sampleDescription;
    TimeToSampleNumAtom        timeToSampleNum;
    SampleToChunkAtom        sampleToChunk;
    SyncSampleAtom            syncSample;
    SampleSizeAtom            sampleSize;
    ChunkOffsetAtom            chunkOffset;

};
typedef struct SampleTableAtom SampleTableAtom;


struct PublicHandlerInfo {
    long                flags;                                /* 1 byte of version / 3 bytes of flags */
    long                componentType;                        /* mhdr or dhdr */
    long                componentSubType;                    /* info to find media handler */
    long                componentManufacturer;
    long                componentFlags;
    long                componentFlagsMask;
    char                componentName[1];

};
typedef struct PublicHandlerInfo PublicHandlerInfo;

struct HandlerAtom {
    long                size;
    long                type;                            /* = 'hdlr' */

    PublicHandlerInfo    hInfo;
};
typedef struct HandlerAtom HandlerAtom;


typedef long DataRefAtom;                                /* a data reference is a private structure */

struct DataInfoAtom {
    long                size;
    long                type;                            /* = 'dinf' */
    DataRefAtom            dataRef;
};
typedef struct DataInfoAtom DataInfoAtom;

struct RgnAtom {
    long        size;
    long        type;

    long        flags;                                    /* 1 byte of version / 3 bytes of flags */

    short        rgnSize;
    Rect        rgnBBox;
    char        data[1];
};
typedef struct RgnAtom RgnAtom;

struct MatteAtom {
    long        size;
    long        type;

    long        flags;                                    /* 1 byte of version / 3 bytes of flags */

    PixMap        mattePixMap;
    ColorTable    matteColorTable;
};
typedef struct MatteAtom MatteAtom;

struct ClippingAtom {
    long        size;
    long        type;

    RgnAtom        aRgnClip;
};
typedef struct ClippingAtom ClippingAtom;

struct VideoMediaInfoHeader {
    long                flags;                            /* 1 byte of version / 3 bytes of flags */
    short                graphicsMode;                    /* for QD - transfer mode */
    short                opColorRed;                        /* opcolor for transfer mode */
    short                opColorGreen;
    short                opColorBlue;

};
typedef struct VideoMediaInfoHeader VideoMediaInfoHeader;


struct VideoMediaInfoHeaderAtom {
    long                size;                            /* size of Media info */
    long                type;                            /* = 'vmhd' */
    VideoMediaInfoHeader    vmiHeader;
};
typedef struct VideoMediaInfoHeaderAtom VideoMediaInfoHeaderAtom;

struct VideoMediaInfo {
    long                size;                            /* size of Media info */
    long                type;                            /* = 'minf' */
    VideoMediaInfoHeaderAtom    header;
    HandlerAtom            dataHandler;
    DataInfoAtom        dataInfo;
    SampleTableAtom        sampleTable;
};
typedef struct VideoMediaInfo VideoMediaInfo;


struct SoundMediaInfoHeader {
    long                flags;                            /* 1 byte of version / 3 bytes of flags */

     short                balance;
    short                rsrvd;

};
typedef struct SoundMediaInfoHeader SoundMediaInfoHeader;

struct SoundMediaInfoHeaderAtom {
    long                size;                            /* size of Media info */
    long                type;                            /* = 'vmhd' */

    SoundMediaInfoHeader    smiHeader;
};
typedef struct SoundMediaInfoHeaderAtom SoundMediaInfoHeaderAtom;

struct SoundMediaInfo {
    long                size;                            /* size of Media info */
    long                type;                            /* = 'minf' */

    SoundMediaInfoHeaderAtom    header;

    HandlerAtom            dataHandler;

    DataRefAtom            dataReference;

    SampleTableAtom        sampleTable;
};
typedef struct SoundMediaInfo SoundMediaInfo;

struct MediaInfo {
    long            size;
    long            type;

    /* whatever data the media handler needs goes here */
};
typedef struct MediaInfo MediaInfo;


/***********************
* Media Directory Structures
***********************/

struct MediaHeader {
    long                flags;                            /* 1 byte of version / 3 bytes of flags */

    long                creationTime;                    /* seconds since Jan 1904 when directory was created */
    long                modificationTime;                /* seconds since Jan 1904 when directory was appended */

    TimeValue            timeScale;                        /* start time for Media (Media time) */
    TimeValue            duration;                        /* length of Media (Media time) */

    short                language;
    short                quality;
};
typedef struct MediaHeader MediaHeader;

struct MediaHeaderAtom {
    long         size;
    long        type;

    MediaHeader    header;
};
typedef struct MediaHeaderAtom MediaHeaderAtom;

struct MediaDirectory {
    long                size;
    long                type;                            /* = 'mdia' */

    MediaHeaderAtom            mediaHeader;                /* standard Media information */

    HandlerAtom            mediaHandler;

    MediaInfo            mediaInfo;
} ;
typedef struct MediaDirectory MediaDirectory;


/***********************
* Track Structures
***********************/

enum {
    TrackEnable = 1<<0,
    TrackInMovie = 1<<1,
    TrackInPreview = 1<<2,
    TrackInPoster = 1<<3
    };

struct TrackHeader {
    long                flags;                            /* 1 byte of version / 3 bytes of flags */

    long                creationTime;                    /* seconds since Jan 1904 when directory was created */
    long                modificationTime;                /* seconds since Jan 1904 when directory was appended */

    long                trackID;

    TimeValue            formerTrackTimeScale;            /* start time for track (track time) */
    TimeValue            duration;                        /* length of track (track time) */
    TimeValue            movieTimeOffset;                /* this offset is in movie time */

    PriorityType        priority;
    short                layer;
    short                alternateGroup;

    short                volume;
    short                reserved1;

    MatrixRecord        matrix;
    Fixed                trackWidth;
    Fixed                trackHeight;

} ;
typedef struct TrackHeader TrackHeader;

struct TrackHeaderAtom {
    long                size;                            /* size of track header */
    long                type;                            /* = 'tkhd' */

    TrackHeader        header;
};
typedef struct TrackHeaderAtom TrackHeaderAtom;

struct EditListType {
    TimeValue        trackDuration;
    TimeValue        mediaTime;
    Fixed            mediaRate;
};
typedef struct EditListType EditListType;

struct EditListAtom {
    long                size;
    long                type;                            /* = elst */

    long                flags;                            /* 1 byte of version / 3 bytes of flags */

    long                numEntries;
    EditListType        editListTable[1];
};
typedef struct EditListAtom EditListAtom;

struct EditsAtom {
    long            size;
    long            type;                                /* = edts */

    EditListAtom    editList;
};
typedef struct EditsAtom EditsAtom;

struct TrackDirectory {
    long                size;
    long                type;                            /* = 'trak' */

    TrackHeaderAtom            trackHeader;                /* standard track information */

    ClippingAtom        trackClip;

    EditsAtom            edits;

    MediaDirectory        media;

     UserDataAtom        userData;                        /* space for extending with new data types */
} ;
typedef struct TrackDirectory TrackDirectory;

struct MovieHeader {
    long                flags;                            /* 1 byte of version / 3 bytes of flags */

    long                creationTime;                    /* seconds since Jan 1904 when directory was created */
    long                modificationTime;                /* seconds since Jan 1904 when directory was appended */

    /* Time specifications */
    TimeValue            timeScale;
    TimeValue            duration;
    Fixed                preferredRate;                    /* rate at which to play this movie */

    short                preferredVolume;                /* volume to play movie at */
    short                reserved1;

    /* Graphics specifications */
    long                preferredLong1;
    long                preferredLong2;
/* option is to have a preferred matrix here */
    MatrixRecord        matrix;
    TimeValue            previewTime;                    /* time in track the proxy begins (track time) */
    TimeValue            previewDuration;                /* how long the proxy lasts (track time) */
    TimeValue            posterTime;                        /* time in track the proxy begins (track time) */
    TimeValue            selectionTime;                    /* time in track the proxy begins (track time) */
    TimeValue            selectionDuration;                /* time in track the proxy begins (track time) */
    TimeValue            currentTime;                    /* time in track the proxy begins (track time) */
    long                 nextTrackID;                    /* next value to use for a TrackID */

};
typedef struct MovieHeader MovieHeader;

struct MovieHeaderAtom {
    long                size;
    long                type;                            /* = 'mvhd' */
    MovieHeader         header;
};
typedef struct MovieHeaderAtom MovieHeaderAtom;

struct MovieDirectory {
    long                size;
    long                type;                            /* = 'moov' */
    MovieHeaderAtom        header;
    ClippingAtom        movieClip;

    /* Track Directories */
    struct {
        TrackDirectory  trackDirectory;                 /* Track directory information */
        }                 track[1];

     /* User data for Movie */
     UserDataAtom        userData;                        /* space for user extensions */

};
typedef struct MovieDirectory MovieDirectory;
/* Movie formats and tags */
    /* some system defined format IDs */
    #define    MOVIE_TYPE        'moov'
    #define TRACK_TYPE        'trak'
    #define MEDIA_TYPE        'mdia'
    #define VIDEO_TYPE        'vide'
    #define SOUND_TYPE        'soun'
    #define MIDI_TYPE        'midi'

    #define EMPTY_TAG        0x00

    #define    TEXT_TYPE                'text'
    /* An example of some common name sub-types. */
    #define    COPYRIGHT_TEXT            'cprt'
    #define    SOURCE_NAME_CUSTOM        'snam'


/* atom id's */
    #define MovieAID                'moov'
    #define MovieHeaderAID            'mvhd'
    #define ClipAID                    'clip'
    #define RgnClipAID                'crgn'
    #define MatteClipAID            'cmat'
    #define MatteImageDescAID         'mtid'
    #define MatteDataAID            'mtda'
    #define TrackAID                'trak'
    #define    UserDataAID                'udta'
    #define    TrackHeaderAID            'tkhd'
    #define EditsAID                'edts'
    #define EditListAID                'elst'
    #define MediaAID                'mdia'
    #define MediaHeaderAID            'mdhd'
    #define    MediaInfoAID            'minf'
    #define MediaInfoHeaderAID        'mihd'
    #define VideoMediaInfoHeaderAID    'vmhd'
    #define SoundMediaInfoHeaderAID    'smhd'
    #define DataInfoAID                'dinf'
    #define DataRefAID                'dref'
    #define SampleTableAID            'stbl'
    #define STSampleDescAID            'stsd'
    #define STGroupToSampAID        'stgs'
    #define STSyncSampleAID            'stss'
    #define STSampleToChunkAID        'stsc'
    #define HandlerAID                'hdlr'
    #define STSampleSizeAID            'stsz'
    #define STChunkOffsetAID        'stco'

    #define DataRefBlobAID 'blob'
    #define DataRefContainerAID 'drfc'


#endif __MOVIESFORMAT__